@automagik/omni 2.260914.8 → 2.260914.10

package/dist/index.js

@@ -137252,7 +137252,7 @@ import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "@automagik/omni",
-  version: "2.260914.8",
+  version: "2.260914.10",
   repository: {
     type: "git",
     url: "git+https://github.com/automagik-dev/omni.git",

package/dist/server/index.js

@@ -44926,11 +44926,14 @@ class BaseChannelPlugin {
       ingestMode: isHistorySync ? "history-sync" : "realtime"
     };
     return this.publishClaimed("message.received", payload, instanceId, {
-      idempotencyKey: `${this.id}:${instanceId}:${payload.externalId}:${payload.content.type}`,
+      idempotencyKey: `${this.id}:${instanceId}:${this.ingressKeyId(payload.chatId, payload.externalId)}:${payload.content.type}`,
       externalId: payload.externalId,
       options
     });
   }
+  ingressKeyId(_chatId, id) {
+    return id;
+  }
   async publishClaimed(type, payload, instanceId, params) {
     const { idempotencyKey, externalId, options = {} } = params;
     if (!this.ingressClaim) {
@@ -44960,11 +44963,19 @@ class BaseChannelPlugin {
   reactionClaimParams(kind, instanceId, payload) {
     const raw = payload.rawPayload?.externalId;
     const externalId = typeof raw === "string" && raw.length > 0 ? raw : `${payload.messageId}:${payload.from}`;
-    return { idempotencyKey: `${this.id}:${instanceId}:${externalId}:${kind}:${payload.emoji}`, externalId };
+    const keyId = this.ingressKeyId(payload.chatId, externalId);
+    return { idempotencyKey: `${this.id}:${instanceId}:${keyId}:${kind}:${payload.emoji}`, externalId };
   }
   async emitMessageSent(params) {
     const { instanceId, ...payload } = params;
-    await this.publishEventInternal("message.sent", payload, instanceId);
+    if (!payload.externalId) {
+      await this.publishEventInternal("message.sent", payload, instanceId);
+      return;
+    }
+    await this.publishClaimed("message.sent", payload, instanceId, {
+      idempotencyKey: `${this.id}:${instanceId}:${this.ingressKeyId(payload.chatId, payload.externalId)}:message.sent`,
+      externalId: payload.externalId
+    });
   }
   async emitMessageFailed(params) {
     const { instanceId, ...payload } = params;
@@ -250935,7 +250946,7 @@ var init_sentry_scrub = __esm(() => {
 var require_package7 = __commonJS((exports, module) => {
   module.exports = {
     name: "@omni/api",
-    version: "2.260914.8",
+    version: "2.260914.10",
     private: true,
     type: "module",
     exports: {
@@ -362462,7 +362473,7 @@ function createIngressClaim(db2) {
           channel: channelTypes.includes(channelType) ? channelType : "discord",
           instanceId,
           eventType,
-          direction: "inbound",
+          direction: eventType === "message.sent" ? "outbound" : "inbound",
           status: "received",
           idempotencyKey,
           receivedAt: new Date,
@@ -397426,11 +397437,11 @@ async function setupMessageListener(eventBus) {
   try {
     await eventBus.subscribe("message.received", async (event) => {
       const { externalId, chatId, from, content, rawPayload } = event.payload;
-      const _instanceId = event.metadata.instanceId;
-      messageLog.info("Received", { from, chatId, externalId });
-      messageLog.debug("Payload", { content: JSON.stringify(content) });
+      const { instanceId, channelType } = event.metadata;
+      messageLog.info("Received", { instanceId, channel: channelType, from, chatId, externalId });
+      messageLog.debug("Payload", { instanceId, content: JSON.stringify(content) });
       if (process.env.DEBUG_PAYLOADS === "true" && rawPayload) {
-        messageLog.debug("Raw payload", { rawPayload });
+        messageLog.debug("Raw payload", { instanceId, rawPayload });
       }
     });
     messageLog.info("Listening for message.received events");
@@ -397671,8 +397682,7 @@ async function setupEventPersistence(eventBus, db2) {
           const sdb = scopedHandle(db2);
           const chatLink = await resolveChatLink(sdb, metadata.instanceId, payload.chatId);
           const replyToEventId = await resolveReplyToEventId(sdb, metadata.instanceId, payload.replyToId);
-          const newEvent = {
-            ...eventIdInsert(event.id),
+          const columns2 = {
             externalId: payload.externalId,
             channel: mapChannelType(metadata.channelType),
             instanceId: metadata.instanceId,
@@ -397702,7 +397712,7 @@ async function setupEventPersistence(eventBus, db2) {
             conversationId: null,
             ...chatLink
           };
-          await sdb.insert(omniEvents).values(newEvent).onConflictDoNothing({ target: omniEvents.id });
+          await sdb.insert(omniEvents).values({ ...eventIdInsert(event.id), ...columns2 }).onConflictDoUpdate({ target: omniEvents.id, set: columns2 });
         });
         log127.debug("Persisted message.sent", {
           externalId: payload.externalId,
@@ -410017,6 +410027,7 @@ var import_bolt = __toESM(require_dist16(), 1);
 var import_web_api = __toESM(require_dist13(), 1);
 var HTTP_MAX_BODY_BYTES = 1024 * 1024;
 var SOCKET_OPEN_TIMEOUT_MS = 1e4;
+var SOCKET_STALE_AFTER_MS = 5 * 60000;
 function buildActingClients(options, botClient) {
   if (options.authMode !== "user")
     return { actingClient: botClient };
@@ -410078,8 +410089,15 @@ function watchSocketLifecycle(connection, logger5) {
     connection.socketState = state;
     connection.onSocketStateChange?.(state);
   };
+  const touch = () => {
+    connection.lastSocketActivityAt = Date.now();
+  };
+  socketClient.on("ws_message", touch);
   socketClient.on("connected", () => {
     logger5.info("Slack Socket Mode WebSocket connected");
+    touch();
+    const raw = socketClient.websocket?.websocket;
+    raw?.on?.("ping", touch);
     transition("connected");
   });
   socketClient.on("reconnecting", () => {
@@ -410219,6 +410237,7 @@ async function resolveIdentities(connection, logger5) {
   try {
     const authResult = await connection.app.client.auth.test();
     connection.botUserId = authResult.user_id ?? undefined;
+    connection.botId = authResult.bot_id ?? undefined;
     connection.botName = authResult.user ?? undefined;
     connection.teamId = authResult.team_id ?? undefined;
     connection.teamName = authResult.team ?? undefined;
@@ -410275,9 +410294,15 @@ function isSocketOpen(connection) {
     return false;
   const websocket = socketClient.websocket;
   if (websocket)
-    return websocket.isActive();
+    return websocket.isActive() && !isSocketStale(connection);
   return connection.socketState === "connected";
 }
+function isSocketStale(connection, now = Date.now()) {
+  const last = connection.lastSocketActivityAt;
+  if (last === undefined)
+    return false;
+  return now - last > (connection.socketStaleAfterMs ?? SOCKET_STALE_AFTER_MS);
+}
 async function destroyBoltConnection(connection, logger5) {
   connection.onSocketStateChange = undefined;
   try {
@@ -410627,12 +410652,14 @@ function extractMessageMeta(event) {
     channelType
   };
 }
-function shouldSkipMessage(msg, selfUserIds) {
-  if (msg.subtype === "bot_message" || msg.bot_id)
-    return true;
+function shouldSkipMessage(msg, selfUserIds, ownBotId) {
   if (msg.subtype === "message_changed" || msg.subtype === "message_deleted")
     return true;
   const userId = msg.user;
+  if (msg.subtype === "bot_message" && !userId)
+    return true;
+  if (msg.bot_id && (!userId || msg.bot_id === ownBotId))
+    return true;
   if (!userId)
     return true;
   if (selfUserIds.some((id) => id && id === userId))
@@ -410754,20 +410781,30 @@ async function processMessage2(instanceId, msg, currentBotUserId, callbacks, log
   }
   await callbacks.onMessage(instanceId, meta.ts, meta.channelId, userId, content, replyToId, rawPayload, platformTimestamp, meta);
 }
-function setupMessageHandlers2(app, instanceId, botUserId, callbacks, dmPolicyConfig, logger5, filterConfig, reliability, actingUserId) {
+function setupMessageHandlers2(app, instanceId, botUserId, callbacks, dmPolicyConfig, logger5, filterConfig, reliability, actingUserId, ownBotId) {
   const resolveBotUserId = () => typeof botUserId === "function" ? botUserId() : botUserId;
   const resolveActingUserId = () => typeof actingUserId === "function" ? actingUserId() : actingUserId;
-  app.message(async ({ message: message2 }) => {
-    const msg = message2;
-    if (shouldSkipMessage(msg, [resolveBotUserId(), resolveActingUserId()]))
+  const handle = async (msg) => {
+    if (shouldSkipMessage(msg, [resolveBotUserId(), resolveActingUserId()], ownBotId?.())) {
+      logger5.debug("Message skipped: bot/self/edit", {
+        instanceId,
+        channelId: msg.channel,
+        ts: msg.ts,
+        subtype: msg.subtype,
+        botId: msg.bot_id,
+        userId: msg.user
+      });
       return;
+    }
     const userId = msg.user;
     const meta = extractMessageMeta(msg);
     if (await enforceDmPolicy(meta, userId, dmPolicyConfig, instanceId, callbacks, logger5))
       return;
     await processMessage2(instanceId, msg, resolveBotUserId(), callbacks, logger5, reliability, filterConfig);
-  });
+  };
+  app.message(async ({ message: message2 }) => handle(message2));
   logger5.info("Message handlers registered", { instanceId });
+  return handle;
 }
 
 // ../channel-slack/src/handlers/pins.ts
@@ -411586,6 +411623,8 @@ class SlackPlugin extends BaseChannelPlugin {
   presenceStatusTimers = new Map;
   pendingAckReactions = new Map;
   activeNativeStreams = new Map;
+  lastSeenTs = new Map;
+  inboundHandlers = new Map;
   async onInitialize(_context) {}
   async onDestroy() {
     for (const [instanceId, connection] of this.connections) {
@@ -411677,6 +411716,7 @@ class SlackPlugin extends BaseChannelPlugin {
         ownerIdentifier: connection.botUserId
       });
       this.watchSocketState(instanceId, config2, connection);
+      this.backfillMissedMessages(instanceId, connection);
       this.logger.info("Slack instance connected", {
         instanceId,
         botName: connection.botName,
@@ -411706,6 +411746,8 @@ class SlackPlugin extends BaseChannelPlugin {
     await destroyBoltConnection(connection, this.logger);
     this.connections.delete(instanceId);
     this.slackConfigs.delete(instanceId);
+    this.lastSeenTs.delete(instanceId);
+    this.inboundHandlers.delete(instanceId);
     for (const key of this.userNameCache.keys()) {
       if (key.startsWith(`${instanceId}:`))
         this.userNameCache.delete(key);
@@ -411765,6 +411807,7 @@ class SlackPlugin extends BaseChannelPlugin {
         return;
       if (state === "connected") {
         this.logger.info("Slack Socket Mode connection restored", { instanceId });
+        this.backfillMissedMessages(instanceId, connection);
         setStatus({
           state: "connected",
           since: new Date,
@@ -412218,7 +412261,7 @@ class SlackPlugin extends BaseChannelPlugin {
         cursor
       });
       for (const msg of response.messages ?? []) {
-        const result = await this.buildHistorySyncMessage(msg, channelId, botUserId, botToken);
+        const result = await this.buildHistorySyncMessage(msg, channelId, botUserId, botToken, connection.botId);
         if (result)
           messages.push(result);
         if (messages.length >= maxMessages)
@@ -412244,9 +412287,9 @@ class SlackPlugin extends BaseChannelPlugin {
       return { mimeType, localPath: undefined };
     }
   }
-  async buildHistorySyncMessage(msg, channelId, botUserId, botToken) {
+  async buildHistorySyncMessage(msg, channelId, botUserId, botToken, ownBotId) {
     const userId = msg.user;
-    if (msg.bot_id || botUserId && userId === botUserId || !userId)
+    if (!userId || shouldSkipMessage(msg, [botUserId], ownBotId))
       return null;
     const ts = msg.ts;
     const text = msg.text ?? "";
@@ -412362,6 +412405,83 @@ class SlackPlugin extends BaseChannelPlugin {
       instanceId
     });
   }
+  recordSeen(instanceId, msg) {
+    const channelId = msg.channel;
+    const ts = msg.ts;
+    if (!channelId || !ts)
+      return;
+    let seen = this.lastSeenTs.get(instanceId);
+    if (!seen) {
+      seen = new Map;
+      this.lastSeenTs.set(instanceId, seen);
+    }
+    const threadTs = msg.thread_ts;
+    const keys = threadTs && threadTs !== ts ? [channelId, `${channelId}:${threadTs}`] : [channelId];
+    for (const key of keys) {
+      const prev = seen.get(key);
+      if (!prev || Number.parseFloat(ts) > Number.parseFloat(prev))
+        seen.set(key, ts);
+    }
+  }
+  async backfillMissedMessages(instanceId, connection) {
+    const seen = this.lastSeenTs.get(instanceId);
+    const handle = this.inboundHandlers.get(instanceId);
+    if (!seen?.size || !handle)
+      return 0;
+    const missed = new Map;
+    const collect = (channelId, oldest, msgs) => {
+      for (const raw of msgs ?? []) {
+        const ts = raw.ts;
+        if (!ts || Number.parseFloat(ts) <= Number.parseFloat(oldest))
+          continue;
+        missed.set(`${channelId}:${ts}`, {
+          ...raw,
+          channel: channelId,
+          channel_type: raw.channel_type ?? (channelId.startsWith("D") ? "im" : undefined)
+        });
+      }
+    };
+    for (const [key, oldest] of [...seen]) {
+      const [channelId, threadTs] = key.split(":");
+      try {
+        if (threadTs) {
+          const res2 = await connection.actingClient.conversations.replies({ channel: channelId, ts: threadTs, oldest });
+          collect(channelId, oldest, res2.messages);
+          continue;
+        }
+        const res = await connection.actingClient.conversations.history({ channel: channelId, oldest, limit: 200 });
+        collect(channelId, oldest, res.messages);
+        for (const parent of res.messages ?? []) {
+          const latestReply = parent.latest_reply;
+          if (!latestReply || Number.parseFloat(latestReply) <= Number.parseFloat(oldest))
+            continue;
+          const replies = await connection.actingClient.conversations.replies({
+            channel: channelId,
+            ts: parent.ts,
+            oldest
+          });
+          collect(channelId, oldest, replies.messages);
+        }
+      } catch (err2) {
+        this.logger.warn("Slack backfill fetch failed", { instanceId, channelId, threadTs, error: String(err2) });
+      }
+    }
+    const ordered = [...missed.values()].sort((a, b2) => Number.parseFloat(a.ts) - Number.parseFloat(b2.ts));
+    for (const msg of ordered) {
+      this.recordSeen(instanceId, msg);
+      try {
+        await handle(msg);
+      } catch (err2) {
+        this.logger.warn("Slack backfill dispatch failed", { instanceId, ts: msg.ts, error: String(err2) });
+      }
+    }
+    this.logger.info("Slack reconnect backfill complete", {
+      instanceId,
+      conversations: seen.size,
+      recovered: ordered.length
+    });
+    return ordered.length;
+  }
   trackActiveThread(instanceId, channelId, threadTs) {
     this.activeThreads.set(`${instanceId}:${channelId}`, threadTs);
   }
@@ -412440,7 +412560,10 @@ class SlackPlugin extends BaseChannelPlugin {
     await this.handleMessageReceived(instanceId, args.externalId, args.chatId, args.from, args.content, args.replyToId, enrichedPayload, args.platformTimestamp);
   }
   setupHandlers(instanceId, connection, config2, reliability) {
-    setupMessageHandlers2(connection.app, instanceId, () => connection.botUserId, {
+    connection.app.message(async ({ message: message2 }) => {
+      this.recordSeen(instanceId, message2);
+    });
+    const handleInbound = setupMessageHandlers2(connection.app, instanceId, () => connection.botUserId, {
       onMessage: async (_instId, externalId, chatId, from, content, replyToId, rawPayload, platformTimestamp, _meta) => {
         const threadTs = rawPayload.threadTs;
         this.trackActiveThread(instanceId, chatId, threadTs ?? externalId);
@@ -412473,7 +412596,8 @@ class SlackPlugin extends BaseChannelPlugin {
       channelAllowlist: config2.channelAllowlist,
       channelBlocklist: config2.channelBlocklist,
       channels: config2.channels
-    }, reliability, () => connection.actingUserId);
+    }, reliability, () => connection.actingUserId, () => connection.botId);
+    this.inboundHandlers.set(instanceId, handleInbound);
     setupReactionHandlers2(connection.app, instanceId, () => connection.botUserId, {
       onReaction: async (instId, messageId, chatId, userId, emoji, action) => {
         await this.handleReactionReceived(instId, messageId, chatId, userId, emoji, action);
@@ -414973,6 +415097,9 @@ class TelegramPlugin extends BaseChannelPlugin {
   configs = new Map;
   cleanups = new Map;
   dedupeCaches = new Map;
+  ingressKeyId(chatId, id) {
+    return `${chatId}:${id}`;
+  }
   typingIntervals = new Map;
   async onInitialize(_context) {
     this.logger.info("Telegram plugin initialized");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automagik/omni",
-  "version": "2.260914.8",
+  "version": "2.260914.10",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/automagik-dev/omni.git",